KvmManager.idl

#ifndef __RADM_KVM_MANAGER_IDL__
#define __RADM_KVM_MANAGER_IDL__
 
#include <UserEvent.idl>
#include <DsamDeviceManager.idl>
#include <KeySetManager.idl>
#include <KvmDevice.idl>
#include <KvmPort.idl>
#include <KvmChannel.idl>
#include <PowerDeviceManager.idl>
#include <PortGroupManager.idl>
#include <AutoScan.idl>
#include <PowerSupply.idl>
#include <LocalPort.idl>
#include <TieredDevice.idl>
#include <TieredDevicePort.idl>
 
module radm {
 
    interface KvmManager {
        constant int ERR_INVALID_ARGUMENT = 1;
        constant int ERR_VM_SHARE_INACCESSIBLE = 2;
        constant int ERR_IMAGE_NOT_USABLE = 3;
 
        enumeration ResetPinMode {
            FACTORY_RESET,                  ///< Trigger a factory reset
            ADMIN_PASSWORD_RESET,           ///< Trigger a reset of the admin password
            DISABLE_ALL_RESET               ///< Disable local reset
        };
 
        enumeration ControlPriority {
            PRIORITY_NONE,              ///< No prioritization, first operator gets control
            PRIORITY_LOCAL,             ///< Prioritize operation via locally attached input device
            PRIORITY_REMOTE             ///< Prioritize operation via remote KVM client
        };
 
        structure SecuritySettings {
            boolean pcShare;                    ///< Whether PC sharing is enabled
            int pcShareIdleTimeout;             ///< PC share idle timeout (in seconds)
            boolean vmShare;                    ///< Whether virtual media sharing is enabled
            boolean kvmEncryption;              ///< Whether or not KVM client traffic is encrypted
            boolean disableLocalPortOutput;     ///< Disable video output of locally attached monitors
            ControlPriority controlPriority;    ///< Priority handling for simultaneous keyboard/mouse operation
            ResetPinMode resetPinMode;          ///< Handling of pin-hole reset on device
            boolean sshDpa;                     ///< Whether SSH direct port access is enabled
            boolean urlDpa;                     ///< Whether direct KVM port access via URL is allowed
            boolean allowIFrame;                ///< Allow embedding KVM GUI and HKC client as iframe in other web pages
        };
 
        /** Data structure for a preconfigured virtual media ISO file on an SMB share */
        structure VirtualMediaShare {
            string host;            ///< SMB server host name
            string shareName;       ///< SMB share name
            string imagePath;       ///< Path of ISO image on the SMB share
            boolean enableSMBv1;    ///< Whether to allow SMBv1
        };
 
        enumeration KvmAccessMode {
            FULL_ACCESS,        ///< Both viewing and control are possible
            VIEW_ONLY,          ///< Only viewing is possible
            DENY                ///< Neither viewing nor control are possible
        };
 
        structure KvmAccessFlags {
            KvmAccessMode localAccess;      ///< Access mode for local operation
            KvmAccessMode remoteAccess;     ///< Access mode for remote operation
        };
 
        structure CimFirmwareInfo {
            string cimType;     // matches CimInfo.cimType
            string hwVersion;   // matches CimInfo.hwVersion
            string fwVersion;   // 'output value': FW version for combination above
        };
 
        structure CimUpdateHistoryEntry {
            int port;                       ///< CIM connected port
            string name;                    ///< CIM name
            string type;                    ///< CIM type
            time timestamp;                 ///< Timestamp when the update was started
            string oldVersion;              ///< Previous firmware version
            string imageVersion;            ///< Firmware version of update image
            boolean successful;             ///< Whether update was successful
        };
 
        enumeration VirtualMediaPermission {
            READ_WRITE, ///< read-write virtual media access allowed
            READ_ONLY,  ///< only read-only virtual media access allowed
            VM_DENY     ///< virtual media access not allowed
        };
 
        structure TierPortPermission {
            string portId;                      ///< port ID
            KvmAccessMode allowedKvmAccess;     ///< KVM permission
            VirtualMediaPermission allowedVirtualMediaAccess;   ///< VM permission
            boolean  allowedPowerControl;       ///< Whether power control is permitted
        };
 
        /**
         * Get KVM device
         *
         * @return KVM device
         */
        KvmDevice getKvmDevice();
 
        /**
         * Get KVM channels
         *
         * @return List of available KVM channels
         */
        vector<KvmChannel> getKvmChannels();
 
        /**
         * Get power supplies
         *
         * @return List of power supplies, or empty list in case power supply monitoring is not supported
         */
        vector<PowerSupply> getPowerSupplies();
 
        /**
         * Get power device (PDU) manager
         *
         * @return PDU manager (if supported by device)
         */
        PowerDeviceManager getPowerDeviceManager();
 
        /**
         * Get serial device (DSAM) manager
         *
         * @return DSAM manager (if supported by device)
         */
        DsamDeviceManager getDsamDeviceManager();
 
        /**
         * Get port group manager
         *
         * @return Port group manager (if supported by device)
         */
        PortGroupManager getPortGroupManager();
 
        /**
         * Get key set manager
         *
         * @return Key set manager
         */
        KeySetManager getKeySetManager();
 
        /**
         * Get auto scan instance
         *
         * @return Auto scan instance (if supported by device)
         */
        AutoScan getAutoScan();
 
        /**
         * Get downstream devices tiered to this base device via the Tier port
         *
         * @return Tiered devices
         */
        vector<TieredDevice> getTieredDevices();
 
        /**
         * Get permissions for tiered device ports
         *
         * @param sessionId
         * @return Tier port permissions
         */
        vector<TierPortPermission> getTierPortPermissions(in int sessionId);
 
        /**
         * Get device security settings
         *
         * @return Security settings
         */
        SecuritySettings getSecuritySettings();
 
        /**
         * Set device security settings
         *
         * @param settings New security settings
         *
         * @return 0 on success
         * @return 1 if any setting was invalid
         */
        int setSecuritySettings(in SecuritySettings settings);
 
        /**
         * Get configured virtual media shares
         *
         * @return list of configured virtual media shares
         */
        vector<VirtualMediaShare> getVirtualMediaShares();
 
        /**
         * Configure virtual media shares
         *
         * Note: At most 10 shares can be configured
         *
         * @param shares New list of shares to be sent to KVM clients
         *
         * @return 0 on success
         * @return 1 in case either the list was too long, or any value was invalid
         */
        int setVirtualMediaShares(in vector<VirtualMediaShare> shares);
 
        /**
         * Test a virtual media share
         *
         * @param share Configuration of the share
         * @param username User name for accessing the share
         * @param password Password for accessing the share
         * @param errorDetails Additional error details in case of inaccessible VM share
         *
         * @return 0 on success
         * @return 2 if SMB share can not be accessed
         * @return 3 if image path does not exist on the share or is not a valid image
         */
        int testVirtualMediaShare(in VirtualMediaShare share, in string username, in string password, out string errorDetails);
 
        /**
         * Get current KVM access modes
         *
         * @return Access modes for local and remote operation
         */
        KvmAccessFlags getKvmAccessMode();
 
        /**
         * Get information about available CIM firmwares
         *
         * @return CIM firmware information
         */
        vector<CimFirmwareInfo> getAvailableCimFirmwareVersions();
 
        /**
         * Fetch the CIM firmware update history.
         *
         * @return List of CIM firmware update history entries
         */
        vector<CimUpdateHistoryEntry> getCimUpdateHistory();
 
        /**
         * Start CIM firmware update for selected CIMs
         *
         * @param ports List of ports to which the CIMs to be updated are connected
         */
        void startCimUpdate(in vector<KvmPort> ports);
 
        /** Event: The KVM security settings have changed */
        valueobject KvmSecuritySettingsChangedEvent extends event.UserEvent {
            SecuritySettings oldSettings;           ///< Settings before change
            SecuritySettings newSettings;           ///< Settings after change
        };
 
        /** Event: The list of configured virtual media shares has changed */
        valueobject VirtualMediaSharesChangedEvent extends event.UserEvent {
            vector<VirtualMediaShare> newShares;     ///< Virtual media shares after change
        };
 
        /** Event: Access mode flags have changed */
        valueobject KvmAccessModeChangedEvent extends idl.Event {
            KvmAccessFlags oldAccessFlags;      ///< Access modes before change
            KvmAccessFlags newAccessFlags;      ///< Access modes after change
        };
 
        /** Event: Firmware update base event */
        valueobject CimFirmwareUpdateEvent extends event.UserEvent {
            string oldVersion;              ///< Firmware version the device is being upgraded from
            string newVersion;              ///< Firmware version the device is being upgraded to
        };
 
        /** Event: CIM firmware update started */
        valueobject CimFirmwareUpdateStartedEvent extends CimFirmwareUpdateEvent {};
 
        /** Event: CIM firmware updated successfully */
        valueobject CimFirmwareUpdateCompletedEvent extends CimFirmwareUpdateEvent {};
 
        /** Event: Tiered devices have changed */
        valueobject TieredDevicesChangedEvent extends idl.Event {
            vector<TieredDevice> newDevices;
        };
    };
}
 
#endif //__RADM_KVM_MANAGER_IDL__